//数据结构
// set      weakset（阉割版）    set集合--类似数组，不能重复
// map      weakmap（阉割版）           --类似object，任意类型可以做key


{
  let list = new Set();
  list.add(5);
  list.add(7);

  console.log('size',list.size);          //
}

{
  let arr = [1,2,3,4,5];
  let list = new Set(arr);

  console.log('size',list.size);
}

{
  let list = new Set();
  list.add(1);
  list.add(2);
  list.add(1);                   //重复了

  console.log('list',list);      //set{1,2}

  let arr=[1,2,3,1,'2'];
  let list2=new Set(arr);

  console.log('unique',list2);   //set{1,2,3,'2'}
}

{
  let arr=['add','delete','clear','has'];
  let list=new Set(arr);

  console.log('has',list.has('add'));
  console.log('delete',list.delete('add'),list);
  list.clear();
  console.log('list',list);
}

{ //遍历读取
  let arr=['add','delete','clear','has'];
  let list=new Set(arr);

  for(let key of list.keys()){
    console.log('keys',key);              //'add','delete','clear','has'
  }
  for(let value of list.values()){
    console.log('value',value);           //'add','delete','clear','has'
  }
  for(let [key,value] of list.entries()){ //
    console.log('entries',key,value);
  }

  list.forEach(function(item){console.log(item);})  //'add','delete','clear','has'
}

//---------
//  weakset
//  weakset的区别 1.元素必须是对象；2.元素对象都是弱引用，不会检测对象是否用过，仅仅是地址的引用，不能检测地址是否已经被回收~！
//               3.没有clear方法，4.没有set属性，5.不能遍历
//---------
{
  let weakList=new WeakSet();

  let arg={};

  weakList.add(arg);

  // weakList.add(2);

  console.log('weakList',weakList);
}

//---------
//  map
//---------
{
  let map = new Map();
  let arr=['123'];

  map.set(arr,456);                        //map类型的添加元素，使用set；任何类型都可以做key

  console.log('map',map,map.get(arr));
}

{
  let map = new Map([['a',123],['b',456]]);//{'a'=>123,'b'=>456}
  console.log('map args',map);
  console.log('size',map.size);
  console.log('delete',map.delete('a'),map);
  console.log('clear',map.clear(),map);
}
//---------
//  weakmap
//  weakmap的区别
//---------
{
  let weakmap=new WeakMap();

  let o={};
  weakmap.set(o,123);
  console.log(weakmap.get(o));
}


//  1.map与array的对比
{
    // 数据结构横向对比，增，查，改，删
    let map=new Map();
    let array=[];
    // 增
    map.set('t',1);
    array.push({t:1});

    console.info('map-array',map,array);

    // 查
    let map_exist=map.has('t');
    let array_exist=array.find(item=>item.t);
    console.info('map-array',map_exist,array_exist);

    // 改
    map.set('t',2);
    array.forEach(item=>item.t?item.t=2:'');
    console.info('map-array-modify',map,array);

    // 删
    map.delete('t');
    let index=array.findIndex(item=>item.t);    //数组删除某个元素，需要查到索引~！
    array.splice(index,1);
    console.info('map-array-empty',map,array);
}


//  2.set与array的对比
{
    // set和array的对比
    let set=new Set();
    let array=[];

    // 增
    set.add({t:1});
    array.push({t:1});

    console.info('set-array',set,array);

    // 查
    let set_exist=set.has({t:1});                //这样写肯定是false，因为是对象是引用的，这样直接写是错误的~！
    let array_exist=array.find(item=>item.t);
    console.info('set-array',set_exist,array_exist);

    // 改
    set.forEach(item=>item.t?item.t=2:'');
    array.forEach(item=>item.t?item.t=2:'');
    console.info('set-array-modify',set,array);

    // 删
    set.forEach(item=>item.t?set.delete(item):'');    //set  和  array 的删除都比麻烦
    let index=array.findIndex(item=>item.t);
    array.splice(index,1);
    console.info('set-array-empty',set,array);
}
// 3. map,set,object对比
{
    // map,set,object对比
    let item={t:1};
    let map=new Map();
    let set=new Set();
    let obj={};

    // 增
    map.set('t',1);
    set.add(item);
    obj['t']=1;

    console.info('map-set-obj',obj,map,set);

    // 查
    console.info({
        map_exist:map.has('t'),
        set_exist:set.has(item),
        obj_exist:'t' in obj           //看看 在obj的查询  用 in
    })

    // 改
    map.set('t',2);
    item.t=2;                         //因为set存储的是引用，所以不用直接改set。直接修改数据元素
    obj['t']=2;
    console.info('map-set-obj-modify',obj,map,set);

    // 删除
    map.delete('t');
    set.delete(item);                 //直接删除数据元素，因为set存储的是引用   //和数组比较下~！！！！
    delete obj['t'];                  // obj
    console.info('map-set-obj-empty',obj,map,set);
}

/***
 * //1. 涉及的数据结构，尽量使用map，放弃array
 * //2. 数据要求比较高的时候 使用set（唯一性）
 */


